/**
 * 数据库管理脚本
 * 用于初始化和检查集合状态
 */

// 引入依赖
const { initDatabase } = require('./init_db');
const cloud = require('wx-server-sdk');
cloud.init({ env: cloud.DYNAMIC_CURRENT_ENV });
const db = cloud.database();

// 检查集合状态
async function checkCollectionsStatus() {
  try {
    // 获取所有集合
    const collections = await db.listCollections().get();
    const collectionNames = collections.data.map(collection => collection.name);
    
    console.log('数据库集合列表:');
    collectionNames.forEach(name => console.log(`- ${name}`));
    
    // 检查必要的集合是否存在
    const requiredCollections = ['projects', 'project_branches', 'project_state_history'];
    const missingCollections = requiredCollections.filter(name => !collectionNames.includes(name));
    
    if (missingCollections.length > 0) {
      console.warn('警告: 以下必要集合不存在:');
      missingCollections.forEach(name => console.warn(`- ${name}`));
      console.log('建议运行初始化数据库命令');
    } else {
      console.log('所有必要集合已存在');
    }
    
    return {
      code: 0,
      message: '集合状态检查完成',
      data: {
        allCollections: collectionNames,
        missingCollections
      }
    };
  } catch (error) {
    console.error('检查集合状态失败:', error);
    return {
      code: -1,
      message: '检查集合状态失败: ' + error.message
    };
  }
}

// 获取集合统计信息
async function getCollectionsStats() {
  try {
    const collections = ['projects', 'project_branches', 'project_state_history'];
    const stats = {};
    
    for (const name of collections) {
      try {
        const count = await db.collection(name).count();
        stats[name] = count.total;
      } catch (error) {
        console.warn(`获取集合 ${name} 统计信息失败:`, error.message);
        stats[name] = 'error';
      }
    }
    
    console.log('集合统计信息:');
    Object.entries(stats).forEach(([name, count]) => {
      console.log(`- ${name}: ${count} 条记录`);
    });
    
    return {
      code: 0,
      message: '获取集合统计信息成功',
      data: stats
    };
  } catch (error) {
    console.error('获取集合统计信息失败:', error);
    return {
      code: -1,
      message: '获取集合统计信息失败: ' + error.message
    };
  }
}

// 清空集合中的数据(危险操作，仅用于测试环境)
async function clearCollectionData(collectionName) {
  try {
    // 安全检查：确保只在测试环境执行
    const envId = cloud.DYNAMIC_CURRENT_ENV;
    if (!envId.includes('test') && !envId.includes('dev')) {
      throw new Error('只能在测试环境中清空集合数据');
    }
    
    // 获取所有记录的ID
    const MAX_LIMIT = 100;
    const countResult = await db.collection(collectionName).count();
    const total = countResult.total;
    
    // 分批删除
    const batchTimes = Math.ceil(total / MAX_LIMIT);
    
    for (let i = 0; i < batchTimes; i++) {
      // 查询一批数据
      const records = await db.collection(collectionName)
        .limit(MAX_LIMIT)
        .get();
      
      // 批量删除
      if (records.data.length > 0) {
        const ids = records.data.map(record => record._id);
        
        for (const id of ids) {
          await db.collection(collectionName).doc(id).remove();
        }
        
        console.log(`已删除集合 ${collectionName} 中的 ${ids.length} 条记录`);
      }
    }
    
    console.log(`集合 ${collectionName} 已清空`);
    return {
      code: 0,
      message: `集合 ${collectionName} 已清空`,
      data: { clearedRecords: total }
    };
  } catch (error) {
    console.error(`清空集合 ${collectionName} 失败:`, error);
    return {
      code: -1,
      message: `清空集合 ${collectionName} 失败: ` + error.message
    };
  }
}

// 导出管理函数
module.exports = {
  initDatabase,
  checkCollectionsStatus,
  getCollectionsStats,
  clearCollectionData
};

// 如果直接运行此脚本，执行检查
if (require.main === module) {
  async function main() {
    // 执行集合状态检查
    const statusResult = await checkCollectionsStatus();
    
    // 如果有缺失的集合，执行初始化
    if (statusResult.data.missingCollections.length > 0) {
      console.log('\n开始初始化缺失的集合...');
      await initDatabase();
    }
    
    // 获取集合统计信息
    await getCollectionsStats();
  }
  
  main().then(() => {
    console.log('\n数据库管理操作完成');
    process.exit(0);
  }).catch(error => {
    console.error('\n数据库管理操作失败:', error);
    process.exit(1);
  });
} 